// Agent Boss API 工具函数 - 版本 2.0 (修复字段不匹配问题)
import axios from 'axios'

console.log('🚀 Agent Boss API v2.0 已加载 - 修复字段不匹配问题')

// API基础配置
const API_BASE_URL = 'http://127.0.0.1:8000' // 根据您的后端配置调整

// Agent Boss API 端点配置 - 基于实际后端实现
const AGENT_BOSS_ENDPOINTS = {
  CHAT: '/agent_boss/chat/',  // 主要聊天接口
}

// 创建axios实例
const apiClient = axios.create({
  baseURL: API_BASE_URL,
  timeout: 30000, // 30秒超时
  headers: {
    'Content-Type': 'application/json',
  }
})

// 请求拦截器
apiClient.interceptors.request.use(
  (config) => {
    // 添加认证token
    const token = localStorage.getItem('access_token')
    const userId = localStorage.getItem('userid')
    
    console.log('当前token:', token ? `${token.substring(0, 10)}...` : 'null')
    console.log('当前用户ID:', userId)
    
    if (token) {
      // 检查token格式
      if (token.startsWith('Bearer ')) {
        config.headers.Authorization = token
      } else {
        config.headers.Authorization = `Bearer ${token}`
      }
    } else {
      console.warn('未找到access_token，请求可能失败')
    }
    
    console.log('发送请求:', {
      url: config.url,
      method: config.method,
      headers: config.headers,
      data: config.data
    })
    return config
  },
  (error) => {
    console.error('请求错误:', error)
    return Promise.reject(error)
  }
)

// 响应拦截器
apiClient.interceptors.response.use(
  (response) => {
    console.log('收到响应:', {
      status: response.status,
      statusText: response.statusText,
      data: response.data
    })
    
    // 检查响应数据中是否包含认证错误
    if (response.data && typeof response.data === 'object') {
      const data = response.data
      if (data.message && data.message.includes('无效的Token')) {
        console.error('后端返回认证错误:', data.message)
        // 清除无效的token
        localStorage.removeItem('access_token')
        localStorage.removeItem('userid')
        // 可以在这里添加重定向到登录页的逻辑
      }
    }
    
    return response
  },
  (error) => {
    console.error('响应错误:', error)
    
    // 处理常见错误
    if (error.response?.status === 401) {
      console.error('HTTP 401 未授权错误')
      // 未授权，清除本地存储
      localStorage.removeItem('access_token')
      localStorage.removeItem('userid')
      // 可以在这里添加重定向到登录页的逻辑
    }
    
    return Promise.reject(error)
  }
)

// Token验证和修复工具函数
const validateAndFixToken = () => {
  const token = localStorage.getItem('access_token')
  const userId = localStorage.getItem('userid')
  
  console.log('验证token状态:')
  console.log('- access_token存在:', !!token)
  console.log('- userid存在:', !!userId)
  
  if (token) {
    console.log('- token长度:', token.length)
    console.log('- token前缀:', token.substring(0, 20))
  }
  
  return { token, userId }
}

// 消息内容处理工具函数
const processMessageContent = (response) => {
  // 尝试从不同字段获取消息内容
  let content = response.content || response.message || response.data?.message || response.data?.content || response.data?.response
  
  // 如果content是对象，尝试提取文本
  if (typeof content === 'object') {
    if (content.text) {
      content = content.text
    } else if (content.content) {
      content = content.content
    } else if (content.message) {
      content = content.message
    } else if (content.response) {
      content = content.response
    } else {
      content = JSON.stringify(content)
    }
  }
  
  // 确保返回字符串
  return String(content || '收到回复')
}

// Agent Boss API 类
class AgentBossApi {
  
  // 自动设置测试认证信息（如果没有的话）
  ensureTestAuth() {
    const token = localStorage.getItem('access_token')
    const userId = localStorage.getItem('userid')
    
    console.log('检查认证信息状态:')
    console.log('- access_token存在:', !!token)
    console.log('- userid存在:', !!userId)
    
    if (!token || !userId) {
      console.log('未找到认证信息，设置测试用的认证信息...')
      // 使用最新生成的有效JWT token (用户ID 4)
      const testToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjo0LCJleHAiOjE3NjA5NjIyODgsImlhdCI6MTc2MDM1NzQ4OH0.4yHz5OAru8vtNbhfPweJTltmPHjIYrADu_Jnp-FyFu4'
      localStorage.setItem('access_token', testToken)
      localStorage.setItem('userid', '4')
      console.log('已设置测试认证信息')
      console.log('- 新Token:', testToken.substring(0, 20) + '...')
    } else {
      console.log('认证信息已存在')
      console.log('- Token:', token.substring(0, 20) + '...')
      console.log('- 用户ID:', userId)
    }
  }
  
  // 验证和修复token
  validateToken() {
    return validateAndFixToken()
  }
  
  // 清除所有认证信息
  clearAuth() {
    localStorage.removeItem('access_token')
    localStorage.removeItem('userid')
    localStorage.removeItem('token')
    localStorage.removeItem('auth_token')
    localStorage.removeItem('jwt_token')
    console.log('已清除所有认证信息')
  }
  
  // 设置认证信息
  setAuth(token, userId) {
    localStorage.setItem('access_token', token)
    localStorage.setItem('userid', userId)
    console.log('已设置认证信息')
  }
  
  // 强制刷新Token
  forceRefreshToken() {
    console.log('强制刷新Token...')
    const newToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjo0LCJleHAiOjE3NjA5NjIyODgsImlhdCI6MTc2MDM1NzQ4OH0.4yHz5OAru8vtNbhfPweJTltmPHjIYrADu_Jnp-FyFu4'
    localStorage.setItem('access_token', newToken)
    localStorage.setItem('userid', '4')
    console.log('Token已强制刷新')
    return newToken
  }
  
  // 发送消息到智能招聘助手 - 适配后端API
  async sendMessage(message) {
    // 确保有认证信息
    this.ensureTestAuth()
    
    // 确保message是字符串类型
    const messageStr = String(message || '')
    
    // 添加调试信息
    console.log('sendMessage调用:', {
      originalMessage: message,
      messageStr: messageStr,
      messageLength: messageStr.length,
      messageType: typeof messageStr,
      isEmpty: !messageStr.trim()
    })
    
    // 检查消息是否为空
    if (!messageStr.trim()) {
      console.error('消息为空，无法发送')
      throw new Error('消息不能为空')
    }
    
    try {
      // 生成会话ID
      const sessionId = `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
      
      const requestData = {
        question: messageStr,  // 后端期望的字段名是question
        session_id: sessionId,  // 后端期望的字段名是session_id
        user_id: localStorage.getItem('userid') || '1'  // 添加user_id
      }
      
      // 添加调试信息
      console.log('🚀 API v2.0 - 发送的数据:', requestData)
      console.log('🚀 API v2.0 - 字段检查:', {
        hasQuestion: 'question' in requestData,
        hasMessage: 'message' in requestData,
        questionValue: requestData.question,
        messageValue: requestData.message
      })
      
      const response = await apiClient.post(AGENT_BOSS_ENDPOINTS.CHAT, requestData)
      
      // 处理响应数据，确保返回格式一致
      const responseData = response.data
      
      // 后端返回格式: {code: 200, message: "ok", data: {response: "...", user_id: 1, session_id: "..."}}
      if (responseData.code === 200 && responseData.data) {
        return {
          success: true,
          content: responseData.data.response || '',
          message: responseData.data.response || '',
          response: responseData.data.response || '',
          user_id: responseData.data.user_id,
          session_id: responseData.data.session_id,
          timestamp: new Date().toISOString()
        }
      } else {
        throw new Error(responseData.message || '请求失败')
      }
      
    } catch (error) {
      console.error('发送消息失败:', error)
      
      // 提供更详细的错误信息
      if (error.response) {
        console.error('响应状态:', error.response.status)
        console.error('响应数据:', error.response.data)
        
        const errorMessage = error.response.data?.message || error.response.data?.detail || '发送消息失败'
        
        // 如果是认证错误，尝试刷新Token后重试
        if (errorMessage.includes('无效的Token') || errorMessage.includes('认证失败')) {
          console.log('检测到认证错误，尝试刷新Token...')
          this.forceRefreshToken()
          
          // 重试一次
          try {
            console.log('使用新Token重试...')
            const retryResponse = await apiClient.post(AGENT_BOSS_ENDPOINTS.CHAT, {
              question: messageStr,
              session_id: sessionId,
              user_id: localStorage.getItem('userid') || '1'
            })
            
            const retryResponseData = retryResponse.data
            if (retryResponseData.code === 200 && retryResponseData.data) {
              return {
                success: true,
                content: retryResponseData.data.response || '',
                message: retryResponseData.data.response || '',
                response: retryResponseData.data.response || '',
                user_id: retryResponseData.data.user_id,
                session_id: retryResponseData.data.session_id,
                timestamp: new Date().toISOString()
              }
            }
          } catch (retryError) {
            console.error('重试失败:', retryError)
          }
        }
        
        throw new Error(errorMessage)
      } else if (error.request) {
        console.error('请求失败:', error.request)
        throw new Error('网络连接失败，请检查后端服务是否运行')
      } else {
        throw new Error(error.message || '发送消息失败')
      }
    }
  }

  // 获取可用工具列表 - 基于后端实际工具
  async getAvailableTools() {
    // 后端没有专门的工具列表接口，返回预定义的工具
    return {
      tools: [
        {
          name: 'ResumeGenerateOrAnalyze',
          description: '解析/生成/优化简历：输入为json或文本，输出结构化或docx路径'
        },
        {
          name: 'JobSearch',
          description: '职位检索：传入关键词(岗位/标签/城市关键字)，直接返回前10条职位明细(JSON)'
        },
        {
          name: 'KnowledgeSearch',
          description: '知识检索：对问题进行混合检索并返回结果数量'
        }
      ]
    }
  }

  // 使用特定工具 - 通过聊天接口间接使用
  async useTool(toolName, parameters = {}) {
    const toolPrompt = `使用${toolName}工具，参数：${JSON.stringify(parameters)}`
    return await this.sendMessage(toolPrompt)
  }

  // 查询职位信息 - 通过JobSearch工具
  async queryJobs(query) {
    const jobPrompt = `查询职位：${query}`
    return await this.sendMessage(jobPrompt)
  }

  // 搜索候选人 - 通过简历工具
  async searchCandidates(criteria) {
    const searchPrompt = `搜索候选人，条件：${JSON.stringify(criteria)}`
    return await this.sendMessage(searchPrompt)
  }

  // AI评分候选人
  async scoreCandidate(candidateId, jobId) {
    const scorePrompt = `为候选人${candidateId}评分，职位ID：${jobId}`
    return await this.sendMessage(scorePrompt)
  }

  // 生成职位描述
  async generateJobDescription(jobInfo) {
    const jdPrompt = `生成职位描述：${JSON.stringify(jobInfo)}`
    return await this.sendMessage(jdPrompt)
  }

  // 发送通知
  async sendNotification(notificationData) {
    const notificationPrompt = `发送通知：${JSON.stringify(notificationData)}`
    return await this.sendMessage(notificationPrompt)
  }

  // 安排面试
  async scheduleInterview(interviewData) {
    const interviewPrompt = `安排面试：${JSON.stringify(interviewData)}`
    return await this.sendMessage(interviewPrompt)
  }

  // 解析简历
  async parseResume(file) {
    const parsePrompt = `解析简历文件：${file.name}`
    return await this.sendMessage(parsePrompt)
  }

  // 数据库查询
  async databaseQuery(query) {
    const dbPrompt = `数据库查询：${query}`
    return await this.sendMessage(dbPrompt)
  }

  // 获取聊天历史 - 后端暂不支持，返回空
  async getChatHistory(sessionId = null) {
    console.log('获取聊天历史功能暂未实现')
    return { messages: [] }
  }

  // 清除聊天历史 - 后端暂不支持
  async clearChatHistory(sessionId = null) {
    console.log('清除聊天历史功能暂未实现')
    return { success: true }
  }

  // 获取系统状态
  async getSystemStatus() {
    try {
      const response = await apiClient.get('/agent_boss/debug/')
      return response.data
    } catch (error) {
      console.error('获取系统状态失败:', error)
      return { status: 'unknown', error: error.message }
    }
  }

  // 流式聊天（后端暂不支持）
  async streamChat(message, onChunk, onEnd, onError) {
    console.log('流式聊天功能暂未实现，使用普通聊天')
    try {
      const response = await this.sendMessage(message)
      onChunk && onChunk(response.content, response.content)
      onEnd && onEnd(response.content)
    } catch (error) {
      onError && onError(error)
    }
  }
}

// 创建API实例
const agentBossApi = new AgentBossApi()

// 导出API实例和类
export { agentBossApi, AgentBossApi }
export default agentBossApi
